/**
 * 加载配置中的图层
 */
import ArrayUtil from "../../utils/ArrayUtils/ArrayUtil";
import S3MLayerModel from "../../DataManager/imple/S3MLayerModel";
import ImageryLayerModel from "../../DataManager/imple/ImageryLayerModel";
import VectorLayerModel from "../../DataManager/imple/VectorLayerModel";
import TerrainLayerModel from "../../DataManager/imple/TerrainLayerModel";
import GeoJSONLayerModel from "../../DataManager/imple/GeoJSONLayerModel";
import KmlLayerModel from "../../DataManager/imple/KmlLayerModel";
import Cesium3DTileLayerModel from "../../DataManager/imple/Cesium3DTileLayerModel";
import Snowflake from "../../utils/IDUtils/Snowflake";
import store from "../../store/store";

export default class LoadingLayers {

  /**
   * 添加默认配置中的天地图
   */
  static addTianditu(tiandituConfig){
    let tiandituChildren = [];
    let node;
    if (tiandituConfig.IMG) {
      // console.log(`添加影像`);
      // 在Viewer中添加影像图层
      new ImageryLayerModel().addTiandituImagery("IMG", store.state.tiandituToken);
      // 创建tree节点
      node = this._createElementTreeNode("天地图影像", "tianditu_IMG");
      // 在 tree中添加节点
      tiandituChildren.push(node);
      // 设置节点为选中状态
      store.state.addTreeDefaultCheckedKeysAction(node.id);
    }

    if (tiandituConfig.VEC) {
      // console.log(`添加矢量`);
      new ImageryLayerModel().addTiandituImagery("VEC", store.state.tiandituToken);
      node = this._createElementTreeNode("天地图矢量", "tianditu_VEC");
      store.state.addTreeDefaultCheckedKeysAction(node.id);
      tiandituChildren.push(node);

    }

    if (tiandituConfig.CIA) {
      // console.log(`添加注记`);
      new ImageryLayerModel().addTiandituImagery("CIA", store.state.tiandituToken);
      node = this._createElementTreeNode("天地图标注", "tianditu_CIA");
      store.state.addTreeDefaultCheckedKeysAction(node.id);
      tiandituChildren.push(node);
    }

    if (tiandituChildren.length > 0) {
      store.state.setLayerNameListAction([{
        id: 1,
        label: "公共数据",
        children: tiandituChildren
      }]);
    }
  }

  /**
   * 加载初始化图层
   * 解析图层配置文件并加载图层
   * @param layers
   */
  static andAddLayers(layerInfos){
    console.log(`layerInfos`, layerInfos);

    // 判断图层参数是否为数组类型。如果为数组类型，需要加载多个图层。
    let isArray = ArrayUtil.isArray(layerInfos);
    if (isArray) {
      console.log(`数组类型`, layerInfos);
      for (let layerInfo of layerInfos) {
        this.addLayerByType(layerInfo, true);
      }
    } else {
      this.addLayerByType(layerInfos, true);
    }

  }

  /**
   * 解析图层配置文件并加载图层
   * @param layers
   */
  static analysisAndAddLayers(layers){
    // console.log(`layers`, layers);

    let layerNameTree = this.addLayers(layers);
    // console.log(`layerNameTree`, layerNameTree);
    // let layerNameList = ArrayUtil.mergeArray(layerNameTree, store.state.layerNameList, false);
    store.state.setLayerNameListAction(ArrayUtil.mergeArray(layerNameTree, store.state.layerNameList, false));
    // console.log(`layerNameList`, layerNameList);
  }

  /**
   * 根据配置的场景信息加载场景
   *
   * 基本思路说明
   * "二维":{url:"http://..."} 或 "图层":{"二维图层":[], "三维图层":[]}
   *
   * (0)变量图层配置中所有的key，根据key获取到图层配置信息。
   *
   * (1)判断配置信息是否为 “一个图层配置信息” ，图层配置信息必须存在url配置
   *    直接添加图层
   * (2)判断数据类型是否为 “数组”，多图层配置
   *    for of 获取图层配置
   * (3)对象是一个 “包含下一级分类” 的配置
   *    for in 获取所有的子图层，重复（1）
   *
   *
   */
  static addLayers(layers, parentNodeNameList){

    if (!layers) {
      console.error("错误的图层配置信息，无法添加。", layers);
      return;
    }

    let layerNameTree = [];
    let layerNameChildren;
    let layerNameNode;

    for (const layerKey in layers) {
      // console.log(`layerKey`, layerKey);

      let layerValue = layers[layerKey];

      layerNameNode = this._createElementTreeNode(layerKey);

      // (1)判断参数是否为 一个图层配置信息
      if (layerValue.url || layerValue.cacheType || layerValue.name) {

        layerNameNode.label = layerValue.name ? layerValue.name : layerNameNode.label;
        layerNameNode.descript = layerValue.descript || layerValue.name;
        layerNameNode.layerKey = layerValue.url;
        if (layerValue.show) {
          store.state.addTreeDefaultCheckedKeysAction(layerNameNode.id);
        }

        // 根据图层类型添加图层
        this.addLayerByType(layerValue);

      } else if (ArrayUtil.isArray(layerValue)) {

        // 构建当前节点的子节点
        layerNameChildren = [];

        // (2)判断数据类型是否为数组，多图层配置
        for (const layer of layerValue) {
          // console.log(`layer`, layer);

          let grandson = this._createElementTreeNode(layer.name, layer.url, layer.descript);
          if (layer.show) {
            store.state.addTreeDefaultCheckedKeysAction(grandson.id);
          }

          // 构建叶子节点
          layerNameChildren.push(grandson);

          // 根据图层类型添加图层
          this.addLayerByType(layer);
        }

        layerNameNode.children = layerNameChildren;

      } else {

        // (3)对象是一个包含下一级分类的配置
        layerNameNode.children = this.addLayers(layerValue);
      }

      layerNameTree.push(layerNameNode);

    }

    return layerNameTree;

  }

  /**
   * 创建Element中Tree的节点
   * @param nodeName 节点名称
   * @param key 节点于图层关联的key标识
   * @param desc 当前节点的描述提示
   * @param children 当前节点的子节点
   * @returns {*}
   * @private
   */
  static _createElementTreeNode(nodeName, layerKey, descript, children){

    descript = descript ? descript : nodeName;

    // 中间节点
    if (children) {
      return {
        id: Snowflake.getNextID(),
        label: nodeName,
        descript,
        children
      };
    } else if (layerKey) { // 叶子节点
      return {
        id: Snowflake.getNextID(),
        label: nodeName,
        descript,
        layerKey
      };
    } else {
      return {
        id: Snowflake.getNextID(),
        label: nodeName,
        descript
      };
    }
  }

  /**
   * 旧的版本 - 基于iview
   * 根据配置的场景信息加载场景
   */
  static addLayers2(layers, parentNodeNameList){
    console.log(`layers`, layers);

    let childrens = []; // 当前图层对应的子节点
    let children; // 子节点对象

    // 孙子节点
    let grandson = [];

    // 遍历图层信息
    for (let currentNodeName in layers) {

      parentNodeNameList.push(currentNodeName);

      let layerValue = layers[currentNodeName];

      // 判断当前对象是否还有下一级分类。如果为 "数组类型" 则没有下一级分类，如果为 "对象类型" 说明还有分类。
      let isArray = ArrayUtil.isArray(layerValue);
      if (isArray) {

        grandson = [];
        // 遍历图层配置信息，添加图层
        for (let layerInfo of layerValue) {

          this.addLayerByType(layerInfo);

          let parentNodeNameListStr = JSON.stringify(parentNodeNameList);
          let parentNodeNameListObj = JSON.parse(parentNodeNameListStr);

          let nodeInfo = {
            id: Snowflake.getNextID(),
            url: layerInfo.url,
            label: layerInfo.name
          };
          grandson.push(nodeInfo);
          grandson.push({

            parentNodeNameList: parentNodeNameListObj, // 父节点名称列表
            isLoadLayer: loadLayerFlag, // 是否需要在初始化时加载图层
            url: layerInfo.url,
            // 树表节点信息
            title: layerInfo.name, // 显示在树表的名称
            expand: false, // 是否展开直子节点
            checked: layerInfo.show ? true : false, // 是否勾选子节点
            // selected: layerInfo.show ? true : false // 是否选中子节点
            contextmenu: true // 是否支持右键删除菜单
          });

        }
      }
      else if (layerValue.url || layerValue.name || layerValue.realName) {
        console.error(`此配置方式未实现`);
      }
      else {

        // 还有下一级分类，当前"分类名称"作为下一级的"父级名称"
        grandson = this.addLayers(layerValue, parentNodeNameList);
      }

      // 有子节点才要添加当前节点
      if (grandson.length > 0) {
        children = {
          title: currentNodeName,
          expand: false,
          children: grandson, // 设置当前节点的子节点
          selected: false
        };

        childrens.push(children);
      }

      parentNodeNameList.pop();
    }
    parentNodeNameList.pop();

    return childrens;
  }

  /**
   * 根据图层对应的图层信息添加图层
   * @param layerInfo
   * @param isLoading
   */
  static addLayerByType(layerInfo, isLoading = false){

    // console.log("addLayerByType layerInfo", layerInfo);

    if (!layerInfo || !layerInfo.type) {
      console.error("没有添加图层信息或未设置图层类型");
      return false;
    }

    if (isLoading) {
      layerInfo.isLoading = true;
    } else {
      layerInfo.isLoading = layerInfo.isLoading ? true : false;
    }

    switch (layerInfo.type) {
      case "S3M":
        new S3MLayerModel(layerInfo).addLayer(false);
        break;
      case "IMAGERY":
        new ImageryLayerModel(layerInfo).addLayer(false);
        break;
      case "VECTOR":
        new VectorLayerModel(layerInfo).addLayer(false); // 图层被影像压盖
        break;
      case "TERRAIN":
        new TerrainLayerModel(layerInfo).addLayer(false); // 只会加载第一个地形图层
        break;
      case "GeoJSON":
        new GeoJSONLayerModel(layerInfo).addLayer(false);
        break;
      case "KML":
        new KmlLayerModel(layerInfo).addLayer(false);
        break;
      case "Cesium3DTile":
        new Cesium3DTileLayerModel(layerInfo).addLayer(false); // 功能未完全实现
        break;
      default:
        console.log(`添加图层错误：没有找到指定类型的提供者，图层类型: ${layerInfo.type} ，图层信息：`, layerInfo);
    }
    return true;
  }
}
